home *** CD-ROM | disk | FTP | other *** search
/ NetNews Offline 2 / NetNews Offline Volume 2.iso / news / comp / lang / c++-part1 / 5259 < prev    next >
Encoding:
Text File  |  1996-08-05  |  4.1 KB  |  176 lines
  1. Path: magnus.acs.ohio-state.edu!csn!ub!newserve!rebecca!rpi!not-for-mail
  2. From: Richard Wells <rdwells@mmm.com>
  3. Newsgroups: comp.lang.c++,comp.lang.c++.moderated,comp.lang.c.moderated
  4. Subject: Re: Q: Rigorous coding using #if !defined(...) and #include
  5. Date: 2 Feb 1996 16:08:28 -0000
  6. Organization: 3M Company
  7. Sender: cppmods@netlab.cs.rpi.edu
  8. Approved: devitto@ferndown.ate.slb.com
  9. Message-ID: <4etcts$l50@netlab.cs.rpi.edu>
  10. References: <4eo1fs$rr3@netlab.cs.rpi.edu>
  11. NNTP-Posting-Host: netlab.cs.rpi.edu
  12. X-Original-Date: Fri, 02 Feb 1996 09:43:24 -0600
  13.  
  14. (I see the moderator(s) allowed the crossposting for the
  15. first message, so I'll keep the full list of newsgroups.
  16. I would argue that this applies to C as well as C++ if you
  17. just replace "class" with "struct" in the code below and
  18. make the other obvious necessary syntactical changes.)
  19.  
  20. David Carr wrote:
  21. > 
  22. > In header files, I have used the notation;
  23. > 
  24. > #if !defined (__MYCLASS_H)
  25. > #define (__MYCLASS_H)
  26. > 
  27. > #include "Other.h"
  28. > 
  29. > class MyClass
  30. > {
  31. >         ...// Uses something in Other.h
  32. > };
  33. > 
  34. > #endif
  35. > 
  36. > The problem is this.  I have another class;
  37. > 
  38. > #if !defined (__OTHER_H)
  39. > #define (__OTHER_H)
  40. > 
  41. > #include "MyClass.h"
  42. > 
  43. > class Other
  44. > {
  45. >         ...// Uses something in MyClass.h
  46. > };
  47. > 
  48. > #endif
  49. > 
  50. > and in my source for MyClass.cpp, MyClass.h is obviously
  51. > included.  Now,
  52. > when I try to compile MyClass.cpp, MyClass.h is included and
  53. > __MYCLASS_H
  54. > becomes defined.  Then, MyClass.h #includes Other.h, thus
  55. > defining __OTHER_H.
  56. > Now, Other.h #includes MyClass.h.  As __MYCLASS_H has already
  57. > been defined,
  58. > the code in MyClass.h is not included.  Returning to Other.h,
  59. > this code
  60. > references something in MyClass.h (i.e. its class) and a
  61. > compiler error is
  62. > generated because the symbol/identifier/whatever is unknown.
  63. > 
  64. > What is the preferred method for writing rigorous code and
  65. > solving this
  66. > problem?
  67. > Any suggestions as to how to make H files a complete interface?
  68.  
  69. I find that this can generally be avoided by taking advantage
  70. of the fact that you can use pointers to incomplete types (someone
  71. please correct me if this not the proper C/C++ terminology).  For
  72. example, to flesh out your example a little:
  73.  
  74.   #if !defined (__MYCLASS_H)
  75.   #define (__MYCLASS_H)
  76.  
  77.   #include "Other.h"
  78.  
  79.   class MyClass
  80.   {
  81.       Other *foo;
  82.   };
  83.  
  84.   #endif
  85.  
  86. and in another header
  87.  
  88.   #if !defined (__OTHER_H)
  89.   #define (__OTHER_H)
  90.  
  91.   #include "MyClass.h"
  92.  
  93.   class Other
  94.   {
  95.       MyClass *bar;
  96.   };
  97.  
  98.   #endif
  99.  
  100. The #include statements within the headers can be replaced
  101. by "class Other;" and "class MyCLass;", to get:
  102.  
  103.   #if !defined (__MYCLASS_H)
  104.   #define (__MYCLASS_H)
  105.  
  106.   class Other; // #include replaced by incomplete type
  107.  
  108.   class MyClass
  109.   {
  110.       Other *foo;
  111.   };
  112.  
  113.   #endif
  114.  
  115. and
  116.  
  117.   #if !defined (__OTHER_H)
  118.   #define (__OTHER_H)
  119.  
  120.   class MyClass; // #include replaced by incomplete type
  121.  
  122.   class Other
  123.   {
  124.       MyClass *bar;
  125.   };
  126.  
  127.   #endif
  128.  
  129. I have yet to run into circumstances where this does not
  130. avoid the situation.
  131.  
  132. In fact, I tend to use incomplete types wherever possible
  133. in place of #include.  It keeps compile times down a little,
  134. and IMHO provides for better information hiding.  That is,
  135. in the above example, class Other needs to know that class
  136. MyClass exists, but probably shouldn't be privy to its
  137. internal details, so shouldn't need to #include its header.
  138.  
  139. Just to bore y'all a little longer, if one of the classes
  140. actually contains an instance of the other rather than a
  141. pointer to an instance, than it is necessary to include
  142. the proper header.  For example:
  143.  
  144.   #if !defined (__MYCLASS_H)
  145.   #define (__MYCLASS_H)
  146.  
  147.   class Other;
  148.  
  149.   class MyClass
  150.   {
  151.       Other *foo; // still a pointer
  152.   };
  153.  
  154.   #endif
  155.  
  156. and
  157.  
  158.   #if !defined (__OTHER_H)
  159.   #define (__OTHER_H)
  160.  
  161.   #include "MyClass.h" // need the full definition
  162.  
  163.   class Other
  164.   {
  165.       MyClass bar; // NOT a pointer
  166.   };
  167.  
  168.   #endif
  169.  
  170. Hope this helps.
  171.  
  172.       [ Articles to moderate: mailto:c++-submit@netlab.cs.rpi.edu ]
  173.       [  Read the C++ FAQ: http://www.connobj.com/cpp/cppfaq.htm  ]
  174.       [  Moderation policy: http://www.connobj.com/cpp/guide.htm  ]
  175.       [      Comments? mailto:c++-request@netlab.cs.rpi.edu       ]
  176.